package com.dahua.messagesyncsh.util;

import cn.hutool.core.convert.Convert;
import com.alibaba.fastjson2.JSON;
import org.apache.commons.lang3.StringUtils;

import java.util.Arrays;
import java.util.List;

public class StringUtil {

    public static <T> T convert(Object o, Class<T> clazz) {
        //handle []
        String strip = StringUtils.strip(Convert.toStr(o), "[]");
        try {
            T t = JSON.parseObject(strip, clazz);
            return t;
        }catch (Exception e){
            return null;
        }
    }

    /*
     * 分割字符串
     * */
    public static String intercept(String S, String target, boolean is_forth) {
        StringBuilder result = new StringBuilder();
        int end = isExit(S, target);
        if (is_forth) {
            result.append(S, 0, end - 1);
        } else {
            result.append(S.substring(end));
        }
        return result.toString();
    }

    //KMP匹配算法
    public static int isExit(String S, String T) {
        int[] nextval = getNextval(T);
        //i,j分别表示主串和子串的匹配进度
        int m = S.length(), n = T.length(), i = 0, j = 0;
        //如果i匹配完毕，那么退出循环
        while (i < m) {
            //如果字符相等，那么向后推进i、j
            if (S.charAt(i) == T.charAt(j)) {
                i++;
                j++;
                //如果匹配到了一个完整的子串
                if (j == n) {
                    //返回起始索引
                    return i;
                }
            }
            //如果当前子串进度为0，那么子串不需要回退，主串向后推进i
            else if (j == 0) {
                i++;
            }
            //如果当前子串进度不为0，那么子串需要回退，主串不需要向后推进i
            else {
                //子串进度j回退
                j = nextval[j - 1];
            }
        }
        return -1;
    }

    public static int[] getNextval(String T) {
        int[] next = new int[T.length()];
        char[] chars = T.toCharArray();
        //i表示匹配的字符索引，pre表示前一个子串的最长匹配长度，即next[i-1]
        int i = 1, pre = next[i - 1];
        while (i < T.length()) {
            //如果新增的字符与前一个子串的最长匹配子串前缀的后一个字符相等
            if (chars[i] == chars[pre]) {
                //next[i]=next[i-1]+1
                pre++;
                next[i] = pre;
                //继续后移
                i++;
            }
            //如果不相等，且前一个子串的最长匹配长度不为0
            //那么求i-1的最长匹配长度子串的最长匹配长度子串，即pre=next[next[i-1]-1]
            //然后在下一轮循环中继续比较chars[i] == chars[pre]，此时i并没有自增
            else if (pre != 0) {
                //next[next[i-1]-1]
                pre = next[pre - 1];
            }
            //如果不相等，且前一个子串的最长匹配长度为0，那么说明当前子串的最长匹配长度也为0
            else {//当前子串的最长匹配长度为0
                next[i] = 0;
                //继续后移
                i++;
            }
        }
        return next;
    }

    public static String divided(String s){
        /*  0到9的ascii码为49~57*/
        List <Character> list = Arrays.asList('#','_');
        String res = null;
        int length = s.length();
        Integer split_letter = null;
        Integer split_number = null;
        for (int i = 0; i < length; i++){
            if (list.contains(s.charAt(i))){
                split_letter = i;
            }
            if (s.charAt(i) >= 49 && s.charAt(i) <= 57){
                split_number = i;
            }
        }
        if (split_letter != null){
            split_letter++;
            res = s.substring(split_letter,length);
        }else if (split_number != null){
            split_number++;
            res = s.substring(split_number,length);
        }else {
            res = s;
        }
        return res;
    }
}
